/******************************************************************************
 * @Filename     : gpio.h
 *
 * @Version      : V1.0
 * @Subversion   : $
 * @Last modified: 04/07/2020 16:01:41
 * @Modified by  : Mxy
 *
 * @Brief        : GPIO driver header file
 *
 * Copyright (C) 2020 SKYRELAY Technology co.,Ltd All rights reserved.
 *****************************************************************************/
#ifndef __RC2412_GPIO_DEF_H__
#define __RC2412_GPIO_DEF_H__

#ifdef __cplusplus
extern "C"
{
#endif

#include <stdint.h>
#include "sdk_core/rc24xx.h"

/*---------------------- General Purpose I/O ---------------------------------*/
#define GPIO_PMODE_0_Pos                   (0)
#define GPIO_PMODE_0_Msk                   (0x1ul << GPIO_PMODE_0_Pos)
#define GPIO_PMODE_1_Pos                   (1)
#define GPIO_PMODE_1_Msk                   (0x1ul << GPIO_PMODE_1_Pos)
#define GPIO_PMODE_2_Pos                   (2)
#define GPIO_PMODE_2_Msk                   (0x1ul << GPIO_PMODE_2_Pos)
#define GPIO_PMODE_3_Pos                   (3)
#define GPIO_PMODE_3_Msk                   (0x1ul << GPIO_PMODE_3_Pos)
#define GPIO_PMODE_4_Pos                   (4)
#define GPIO_PMODE_4_Msk                   (0x1ul << GPIO_PMODE_4_Pos)
#define GPIO_PMODE_5_Pos                   (5)
#define GPIO_PMODE_5_Msk                   (0x1ul << GPIO_PMODE_5_Pos)
#define GPIO_PMODE_6_Pos                   (6)
#define GPIO_PMODE_6_Msk                   (0x1ul << GPIO_PMODE_6_Pos)
#define GPIO_PMODE_7_Pos                   (7)
#define GPIO_PMODE_7_Msk                   (0x1ul << GPIO_PMODE_7_Pos)
#define GPIO_PMODE_8_Pos                   (8)
#define GPIO_PMODE_8_Msk                   (0x1ul << GPIO_PMODE_8_Pos)
#define GPIO_PMODE_9_Pos                   (9)
#define GPIO_PMODE_9_Msk                   (0x1ul << GPIO_PMODE_9_Pos)
#define GPIO_PMODE_10_Pos                  (10)
#define GPIO_PMODE_10_Msk                  (0x1ul << GPIO_PMODE_10_Pos)
#define GPIO_PMODE_11_Pos                  (11)
#define GPIO_PMODE_11_Msk                  (0x1ul << GPIO_PMODE_11_Pos)
#define GPIO_PMODE_12_Pos                  (12)
#define GPIO_PMODE_12_Msk                  (0x1ul << GPIO_PMODE_12_Pos)
#define GPIO_PMODE_13_Pos                  (13)
#define GPIO_PMODE_13_Msk                  (0x1ul << GPIO_PMODE_13_Pos)
#define GPIO_PMODE_14_Pos                  (14)
#define GPIO_PMODE_14_Msk                  (0x1ul << GPIO_PMODE_14_Pos)
#define GPIO_PMODE_15_Pos                  (15)
#define GPIO_PMODE_15_Msk                  (0x1ul << GPIO_PMODE_15_Pos)


#define GPIO_DOUT_Pos                      (0)
#define GPIO_DOUT_Msk                      (0xfffffffful << GPIO_DOUT_Pos)

#define GPIO_DOUTMASK_Pos                  (0)
#define GPIO_DOUTMASK_Msk                  (0xfffffffful << GPIO_DOUTMASK_Pos)

#define GPIO_PIN_Pos                       (0)
#define GPIO_PIN_Msk                       (0xfffffffful << GPIO_PIN_Pos)

#define GPIO_INTEN_Pos                     (0)
#define GPIO_INTEN_Msk                     (0xfffffffful << GPIO_INTEN_Pos)

#define GPIO_INTMASK_Pos                   (0)
#define GPIO_INTMASK_Msk                   (0xfffffffful << GPIO_INTMASK_Pos)

#define GPIO_INTTYPE_Pos                   (0)
#define GPIO_INTTYPE_Msk                   (0xfffffffful << GPIO_INTTYPE_Pos)

#define GPIO_INTSTR_Pos                    (0)
#define GPIO_INTSTR_Msk                    (0xfffffffful << GPIO_INTSTR_Pos)

#define GPIO_PIN_MAX     			             16   				 // Specify Maximum Pins of Each GPIO Port

////////////////////////////////////////////////////////////////////////////////////////
//  Analog/Digital Pad Select Definitions                                                        //
////////////////////////////////////////////////////////////////////////////////////////
#define DIGITAL_MODE				0
#define ANALOG_MODE					1

////////////////////////////////////////////////////////////////////////////////////////
//  PMODE Constant Definitions                                                        //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_PMODE_INPUT            0x0UL           // Input Mode
#define GPIO_PMODE_OUTPUT           0x1UL           // Output Mode

////////////////////////////////////////////////////////////////////////////////////////
//  GPIO Interrupt Type Constant Definitions                                          //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_INTTYPE_EDGE           0x0UL           // INTTYPE Setting for Edge Trigger Mode
#define GPIO_INTTYPE_LEVEL          0x1UL           // INTTYPE Setting for Edge Level Mode

////////////////////////////////////////////////////////////////////////////////////////
//  GPIO Interrupt Polarity Constant Definitions                                      //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_INTPOL_RISING          0x0UL           // Interrupt enable by Input Rising Edge
#define GPIO_INTPOL_FALLING         0x1UL           // Interrupt enable by Input Falling Edge
#define GPIO_INTPOL_BOTH_EDGE       0x2UL           // Interrupt enable by both Rising Edge and Falling Edge
#define GPIO_INTPOL_LOW             0x0UL           // Interrupt enable by Level-Level
#define GPIO_INTPOL_HIGH            0x1UL           // Interrupt enable by Level-High

#define GPIO_PIN_ADDR(port, pin)    (*((volatile uint32_t *)((GPIO_PIN_DATA_BASE+(0x40*(port))) + ((pin)<<2))))

#define GPIO0_0                      GPIO_PIN_ADDR(0, 0)
#define GPIO0_1                      GPIO_PIN_ADDR(0, 1)
#define GPIO0_2                      GPIO_PIN_ADDR(0, 2)
#define GPIO0_3                      GPIO_PIN_ADDR(0, 3)
#define GPIO0_4                      GPIO_PIN_ADDR(0, 4)
#define GPIO0_5                      GPIO_PIN_ADDR(0, 5)
#define GPIO0_6                      GPIO_PIN_ADDR(0, 6)
#define GPIO0_7                      GPIO_PIN_ADDR(0, 7)
#define GPIO0_8                      GPIO_PIN_ADDR(0, 8)
#define GPIO0_9                      GPIO_PIN_ADDR(0, 9)
#define GPIO0_10                     GPIO_PIN_ADDR(0, 10)
#define GPIO0_11                     GPIO_PIN_ADDR(0, 11)
#define GPIO0_12                     GPIO_PIN_ADDR(0, 12)
#define GPIO0_13                     GPIO_PIN_ADDR(0, 13)
#define GPIO0_14                     GPIO_PIN_ADDR(0, 14)
#define GPIO0_15                     GPIO_PIN_ADDR(0, 15)


#define GPIO_BSRR_BS0_Pos              (0U)
#define GPIO_BSRR_BS0_Msk              (0x1UL << GPIO_BSRR_BS0_Pos)            /*!< 0x00000001 */
#define GPIO_BSRR_BS0                  GPIO_BSRR_BS0_Msk
#define GPIO_BSRR_BS1_Pos              (1U)
#define GPIO_BSRR_BS1_Msk              (0x1UL << GPIO_BSRR_BS1_Pos)            /*!< 0x00000002 */
#define GPIO_BSRR_BS1                  GPIO_BSRR_BS1_Msk
#define GPIO_BSRR_BS2_Pos              (2U)
#define GPIO_BSRR_BS2_Msk              (0x1UL << GPIO_BSRR_BS2_Pos)            /*!< 0x00000004 */
#define GPIO_BSRR_BS2                  GPIO_BSRR_BS2_Msk
#define GPIO_BSRR_BS3_Pos              (3U)
#define GPIO_BSRR_BS3_Msk              (0x1UL << GPIO_BSRR_BS3_Pos)            /*!< 0x00000008 */
#define GPIO_BSRR_BS3                  GPIO_BSRR_BS3_Msk
#define GPIO_BSRR_BS4_Pos              (4U)
#define GPIO_BSRR_BS4_Msk              (0x1UL << GPIO_BSRR_BS4_Pos)            /*!< 0x00000010 */
#define GPIO_BSRR_BS4                  GPIO_BSRR_BS4_Msk
#define GPIO_BSRR_BS5_Pos              (5U)
#define GPIO_BSRR_BS5_Msk              (0x1UL << GPIO_BSRR_BS5_Pos)            /*!< 0x00000020 */
#define GPIO_BSRR_BS5                  GPIO_BSRR_BS5_Msk
#define GPIO_BSRR_BS6_Pos              (6U)
#define GPIO_BSRR_BS6_Msk              (0x1UL << GPIO_BSRR_BS6_Pos)            /*!< 0x00000040 */
#define GPIO_BSRR_BS6                  GPIO_BSRR_BS6_Msk
#define GPIO_BSRR_BS7_Pos              (7U)
#define GPIO_BSRR_BS7_Msk              (0x1UL << GPIO_BSRR_BS7_Pos)            /*!< 0x00000080 */
#define GPIO_BSRR_BS7                  GPIO_BSRR_BS7_Msk
#define GPIO_BSRR_BS8_Pos              (8U)
#define GPIO_BSRR_BS8_Msk              (0x1UL << GPIO_BSRR_BS8_Pos)            /*!< 0x00000100 */
#define GPIO_BSRR_BS8                  GPIO_BSRR_BS8_Msk
#define GPIO_BSRR_BS9_Pos              (9U)
#define GPIO_BSRR_BS9_Msk              (0x1UL << GPIO_BSRR_BS9_Pos)            /*!< 0x00000200 */
#define GPIO_BSRR_BS9                  GPIO_BSRR_BS9_Msk
#define GPIO_BSRR_BS10_Pos             (10U)
#define GPIO_BSRR_BS10_Msk             (0x1UL << GPIO_BSRR_BS10_Pos)           /*!< 0x00000400 */
#define GPIO_BSRR_BS10                 GPIO_BSRR_BS10_Msk
#define GPIO_BSRR_BS11_Pos             (11U)
#define GPIO_BSRR_BS11_Msk             (0x1UL << GPIO_BSRR_BS11_Pos)           /*!< 0x00000800 */
#define GPIO_BSRR_BS11                 GPIO_BSRR_BS11_Msk
#define GPIO_BSRR_BS12_Pos             (12U)
#define GPIO_BSRR_BS12_Msk             (0x1UL << GPIO_BSRR_BS12_Pos)           /*!< 0x00001000 */
#define GPIO_BSRR_BS12                 GPIO_BSRR_BS12_Msk
#define GPIO_BSRR_BS13_Pos             (13U)
#define GPIO_BSRR_BS13_Msk             (0x1UL << GPIO_BSRR_BS13_Pos)           /*!< 0x00002000 */
#define GPIO_BSRR_BS13                 GPIO_BSRR_BS13_Msk
#define GPIO_BSRR_BS14_Pos             (14U)
#define GPIO_BSRR_BS14_Msk             (0x1UL << GPIO_BSRR_BS14_Pos)           /*!< 0x00004000 */
#define GPIO_BSRR_BS14                 GPIO_BSRR_BS14_Msk
#define GPIO_BSRR_BS15_Pos             (15U)
#define GPIO_BSRR_BS15_Msk             (0x1UL << GPIO_BSRR_BS15_Pos)           /*!< 0x00008000 */
#define GPIO_BSRR_BS15                 GPIO_BSRR_BS15_Msk

#define GPIO_PIN_0                      GPIO_BSRR_BS0 /*!< Select pin 0 */
#define GPIO_PIN_1                      GPIO_BSRR_BS1 /*!< Select pin 1 */
#define GPIO_PIN_2                      GPIO_BSRR_BS2 /*!< Select pin 2 */
#define GPIO_PIN_3                      GPIO_BSRR_BS3 /*!< Select pin 3 */
#define GPIO_PIN_4                      GPIO_BSRR_BS4 /*!< Select pin 4 */
#define GPIO_PIN_5                      GPIO_BSRR_BS5 /*!< Select pin 5 */
#define GPIO_PIN_6                      GPIO_BSRR_BS6 /*!< Select pin 6 */
#define GPIO_PIN_7                      GPIO_BSRR_BS7 /*!< Select pin 7 */
#define GPIO_PIN_8                      GPIO_BSRR_BS8 /*!< Select pin 8 */
#define GPIO_PIN_9                      GPIO_BSRR_BS9 /*!< Select pin 9 */
#define GPIO_PIN_10                     GPIO_BSRR_BS10 /*!< Select pin 10 */
#define GPIO_PIN_11                     GPIO_BSRR_BS11 /*!< Select pin 11 */
#define GPIO_PIN_12                     GPIO_BSRR_BS12 /*!< Select pin 12 */
#define GPIO_PIN_13                     GPIO_BSRR_BS13 /*!< Select pin 13 */
#define GPIO_PIN_14                     GPIO_BSRR_BS14 /*!< Select pin 14 */
#define GPIO_PIN_15                     GPIO_BSRR_BS15 /*!< Select pin 15 */
#define GPIO_PIN_ALL                    (GPIO_BSRR_BS0 | GPIO_BSRR_BS1  | GPIO_BSRR_BS2  | \
                                           GPIO_BSRR_BS3  | GPIO_BSRR_BS4  | GPIO_BSRR_BS5  | \
                                           GPIO_BSRR_BS6  | GPIO_BSRR_BS7  | GPIO_BSRR_BS8  | \
                                           GPIO_BSRR_BS9  | GPIO_BSRR_BS10 | GPIO_BSRR_BS11 | \
                                           GPIO_BSRR_BS12 | GPIO_BSRR_BS13 | GPIO_BSRR_BS14 | \
                                           GPIO_BSRR_BS15) /*!< Select all pins */


////////////////////////////////////////////////////////////////////////////////////////
// @brief       Clear GPIO Pin Interrupt Flag                                         //
//                                                                                    //
// @param[in]   gpio        GPIO port. It could be GPIO0, GPIO1                       //
// @param[in]   u32PinMask  The single or multiple pins of specified GPIO port        //
//                                                                                    //
// @return      None                                                                  //
//                                                                                    //
// @details     Clear the interrupt status of specified GPIO pin.                     //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_CLR_INT_FLAG(gpio, u32PinMask)         ((gpio)->INTSTR = u32PinMask)


////////////////////////////////////////////////////////////////////////////////////////
// @brief       Disable I/O DOUT mask                                                 //
//                                                                                    //
// @param[in]   gpio        GPIO port. It could be GPIO0, GPIO1                       //
// @param[in]   u32PinMask  The single or multiple pins of specified GPIO port        //
//                                                                                    //
// @return      None                                                                  //
//                                                                                    //
// @details     Disable I/O DOUT mask of specified GPIO pin.                          //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_DISABLE_DOUT_Msk(gpio, u32PinMask)    ((gpio)->DOUTMASK &= ~u32PinMask)

////////////////////////////////////////////////////////////////////////////////////////
// @brief       Enable I/O DOUT mask                                                  //
//                                                                                    //
// @param[in]   gpio        GPIO port. It could be GPIO0, GPIO1                       //
// @param[in]   u32PinMask  The single or multiple pins of specified GPIO port        //
//                                                                                    //
// @return      None                                                                  //
//                                                                                    //
// @details     Enable I/O DOUT mask of specified GPIO pin.                           //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_ENABLE_DOUT_Msk(gpio, u32PinMask)     ((gpio)->DOUTMASK |= u32PinMask)

////////////////////////////////////////////////////////////////////////////////////////
// @brief       Get GPIO Pin Interrupt Flag                                           //
//                                                                                    //
// @param[in]   gpio        GPIO port. It could be GPIO0, GPIO1                       //
// @param[in]   u32PinMask  The single or multiple pins of specified GPIO port        //
//                                                                                    //
// @retval      0           No interrupt at specified GPIO pin                        //
// @retval      1           The specified GPIO pin generate an interrupt              //
//                                                                                    //
// @details     Get the interrupt status of specified GPIO pin.                       //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_GET_INT_FLAG(gpio, u32PinMask)         ((gpio)->INTSTR & u32PinMask)

////////////////////////////////////////////////////////////////////////////////////////
// @brief       Get GPIO Port IN Data                                                 //
//                                                                                    //
// @param[in]   gpio GPIO port. It could be GPIO0, GPIO1                              //
//                                                                                    //
// @retval      The specified port data                                               //
//                                                                                    //
// @details     Get the PIN register of specified GPIO port.                          //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_GET_IN_DATA(gpio)   ((gpio)->PIN)
#define GPIO_GET_IN_BIT(gpio, u32Pin)		(((gpio)->PIN & u32Pin) != 0 ? 1 : 0)

////////////////////////////////////////////////////////////////////////////////////////
// @brief       Set GPIO Port OUT Data                                                //
//                                                                                    //
// @param[in]   gpio        GPIO port. It could be GPIO0, GPIO1                       //
// @param[in]   u32Data     GPIO port data                                            //
//                                                                                    //
// @retval      None                                                                  //
//                                                                                    //
// @details     Set the Data into specified GPIO port.                                //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_SET_OUT_DATA(gpio, u32Data)   ((gpio)->DOUT = (u32Data))

////////////////////////////////////////////////////////////////////////////////////////
// @brief       Toggle Specified GPIO pin                                             //
//                                                                                    //
// @param[in]   u32Pin  GPIOx_y x is {0,1}, y is {0,1,...,31}                         //
//                                                                                    //
// @retval      None                                                                  //
//                                                                                    //
// @details     Toggle the specified GPIO pint.                                       //
////////////////////////////////////////////////////////////////////////////////////////
#define GPIO_TOGGLE(u32Pin)   ((u32Pin) ^= 1)



#ifdef __cplusplus
}
#endif

#endif // __GPIO_H__














